/**
 * @date: 2019/8/13
 * @author 风信子
 * @Description: 跳转页面传参数
 * @method routerState
 * @param {object} 参数：$router 参数描述：$router 对象
 * @param {string} 参数：url 参数描述：跳转路由名称
 * @param {object} 参数：params 参数描述：跳转的参数
 * @param {string} 参数：keyName 参数描述：key 名称
 * @return {返回值类型} 返回值说明
 */

export const routerState = (
  $router,
  name,
  params = {},
  keyName = "routerState"
) => {
  sessionStorage.setItem(keyName, JSON.stringify(params));
  $router.push({
    name,
    params,
  });
};

/**
 * @date: 2019/8/13
 * @author 风信子
 * @Description: 获取路由参数  解决刷新页面后state丢失问题
 * @method getRouterState
 * @param {object} 参数：$route 参数描述：$router 对象
 * @return {any} 参数返回
 */
export function getRouterState($route, keyName = "routerState") {
  const { params } = $route;
  return Object.keys(params).length > 0
    ? params
    : JSON.parse(sessionStorage.getItem(keyName));
}

/**
 * @date: 2019/8/13
 * @author 风信子
 * @Description: 工具类方法
 */

export function toFormData(params) {
  const formdata = new FormData();
  // eslint-disable-next-line no-restricted-syntax
  for (const key in params) {
    if (typeof params[key] !== "undefined") {
      formdata.append(key, params[key]);
    }
  }
  return formdata;
}

/**
 * @date: 2020/8/07
 * @author Yzh
 * @Description: 方法说明 去除字符串开始与结束的空格，保留中间空格
 * @method 方法名 removeAllSpace
 * @param {string} 参数：str 参数描述：传入字符串
 * @return {返回值类型} 返回值说明
 */
export function removeStartAndEndSpace(str) {
  return str.replace(/^\s*|\s*$/g, "");
}

/**
 * @date: 2020/8/19
 * @author 风信子
 * @Description: 方法说明 处理数据格式 去逗号
 * @method 方法名 formatData
 * @param {string} 参数名 data  参数说明 包含逗号的数据
 * @param {boolean} 参数名 roToZero  参数说明 是否 - 转 0
 * @return {number | string } 返回值说明 去逗号之后的数据
 */
export function formatData(data, roToZero = false) {
  // 判断是否为 string
  if (typeof data !== "string") {
    return data;
  }
  if (roToZero && data === "-") {
    return 0;
  }
  if (data !== "-") {
    return data.indexOf(",") === -1
      ? parseFloat(data)
      : parseFloat(data.replace(/,/g, ""));
  }
  return data;
}

/**
 * @date: 2020/9/29
 * @author 风信子
 * @Description: 方法说明  获取字符串字节长度
 * @method 方法名 getStrLength
 * @param {参数类型} 参数名 str 参数说明 目标字符串
 * @param {参数类型} 参数名 str 参数说明 字节长度
 * @return {返回值类型} 返回值说明
 */
export function getStrSubstring(str, size) {
  const strCopy = str.replace(/[\u4e00-\u9fa5]/g, "aa");
  if (strCopy.length > size) {
    const oneSize = strCopy.substring(0, size).replace(/aa/g, "").length;
    const twoSize = (size - oneSize) / 2 + oneSize;
    return `${str.substring(0, twoSize)}...`;
  }
  return str;
}

/**
 * @date: 2020/12/18
 * @author 风信子
 * @Description: 方法说明 获取url 参数  如果不传或者是all  这返回所有
 * @method 方法名 getQueryVariable
 * @param {参数类型} 参数名 参数说明
 * @return {返回值类型} 返回值说明
 */
export function getQueryStringData(name = "all") {
  const queryString = window.location.search.substring(1);
  if (queryString !== "") {
    const objAll = {};
    const vars = queryString.split("&");
    for (let i = 0; i < vars.length; i++) {
      const pair = vars[i].split("=");
      if (name === "all") {
        objAll[pair[0]] = pair[1];
      } else if (pair[0] === name) {
        return pair[1];
      }
    }
    console.log(objAll, "ooooo");
    return Object.keys(objAll).length === 0 ? "" : objAll;
  }
  return "";
}

/**
 * @date: 2021/1/4
 * @author Yzh
 * @Description: 根据数据长度转换显示位数以及单位
 * @param {string} data 传入的具体数值
 * @return {{quantity: string, value: string}} value: 转换后的数值 quantity 转换后的数量单位
 */
export function unitConversion(data) {
  let value = formatData(data);
  let quantity = "";
  if (data === "-") {
    return { value: data, quantity };
  }
  const numberSize = Math.round(value).toString().length;
  if (numberSize > 16) {
    quantity = "京";
    value = (value / Math.pow(10, 16)).toFixed(2);
  } else if (numberSize > 12) {
    quantity = "兆";
    value = (value / Math.pow(10, 12)).toFixed(2);
  } else if (numberSize > 8) {
    quantity = "亿";
    value = (value / Math.pow(10, 8)).toFixed(2);
  } else if (numberSize > 4) {
    quantity = "万";
    value = (value / Math.pow(10, 4)).toFixed(2);
  } else {
    return { value: data, quantity };
  }
  const reg =
    value.indexOf(".") > -1 ? /(\d)(?=(\d{3})+\.)/g : /(\d)(?=(?:\d{3})+$)/g;
  value = value.replace(reg, "$1,");
  return { value, quantity };
}

/**
 * @date: 2020/08/31
 * @author 喵帕斯
 * @Description: 配置不同分辨率下input宽度
 * @method getInputWidth
 * @return {返回值类型} 返回值说明
 */
export const getInputWidth = () => {
  // console.log("window.screen.width");
  // console.log(window.screen.width);
  const screenWidth = window.screen.width;
  const configWidthArray = ["150px", "170px", "200px"];
  let width = configWidthArray[0];
  if (screenWidth <= 1300) {
    width = configWidthArray[0];
  } else if (1300 < screenWidth && screenWidth < 1800) {
    width = configWidthArray[1];
  } else if (screenWidth >= 1800) {
    width = configWidthArray[2];
  }
  return width;
};

/**
 * @date: 2021/4/17
 * @author 风信子
 * @Description: 方法说明
 * @method 方法名
 * @param {string} 参数名 sortType 参数说明 0表示默认 1 表示升序 2表示降序
 * @param {string} 参数名 sortKey 参数说明 需要排序的key 名称
 * @param {array} 参数名 sortData 参数说明 数据集合
 * @return {array} 返回值说明 排序后的数据集
 */
export function sortDataMethod(sortType, sortKey, sortData) {
  // a - b 小到大
  const sortNumber = (a, b) => {
    const Avalue = a[sortKey];
    const Bvalue = b[sortKey];
    let data = null;
    if (sortType === "1") {
      // 升序
      data =
        (Avalue === "-" ? Infinity : formatData(Avalue)) -
        (Bvalue === "-" ? Infinity : formatData(Bvalue));
    } else if (sortType === "2") {
      // 降序
      data =
        (Bvalue === "-" ? -Infinity : formatData(Bvalue)) -
        (Avalue === "-" ? -Infinity : formatData(Avalue));
    }
    return data;
  };
  return sortType === "0" ? [...sortData] : sortData.sort(sortNumber);
}

/**
 * @date: 2020/9/29
 * @author 风信子
 * @Description: 方法说明 修改手动loading的信号量, 使用时需在页面注入manualLoadingModels中的manualLoadingValue
 * @method 方法名 changeManualLoadingValue
 * @return {返回值类型} 返回值说明  Promise
 * @param self
 * @param value
 */
export function changeManualLoadingValue(self, value) {
  const { dispatch, manualLoadingValue } = self.props;
  dispatch({
    type: `manualLoadingModels/upManualLoadingValue`,
    payload: manualLoadingValue + value,
  });
  return Promise.resolve();
}

/**
 * @date: 2021/6/7
 * @author 风信子
 * @Description: 方法说明 antd 表格数据转换成下载需要的数据格式
 * @method 方法名 handleDownloadTableData
 * @param {Array} 参数名 thData 参数说明 表头数据
 * @param {Array} 参数名 tbodyData 参数说明 表体数据
 * @param {string} 参数名 nameKey 参数说明 表头名称字段的key 默认是 name | title 否则自己传
 * @param {string} 参数名 idKey 参数说明 表头对应数据的key数据 默认 dataIndex | id 否则自己传
 * @param {string} 参数名 key 参数说明 表体数据如果是对象 默认取 value 否则自己传
 * @return {返回值类型} 返回值说明
 */
export function handleDownloadTableData(
  thData = [],
  tbodyData = [],
  nameKey = "title",
  idKey = "dataIndex",
  key = "value"
) {
  const downloadTbodyKey = []; // 处理出key
  // 处理表头名称
  const tableTitle = thData.map((item) => {
    downloadTbodyKey.push(item?.[idKey] ?? item?.id ?? "");
    return item?.[nameKey] ?? item?.name ?? "";
  });
  // 根据downloadTbodyKey 处理数据格式
  const tableValue = tbodyData.map((item) => {
    const tableList = downloadTbodyKey.map((itemList) => {
      if (getType(item[itemList]) === "string") {
        return item[itemList];
      } else if (getType(item[itemList]) === "object") {
        return item[itemList]?.[key] ?? item[itemList]?.value;
      }
      return "";
    });
    return tableList;
  });
  return {
    title: [tableTitle],
    value: tableValue,
  };
}

/**
 * @date: 2019/11/14
 * @author 风信子
 * @Description: 处理表格下载字段数据
 * @method handleDownloadTableValue
 * @param {object[]} 参数：data 参数描述：表格数据
 * @param {} 参数：data 参数描述：字段顺序
 * @return {返回值类型} 返回值说明
 */
export function handleDownloadTableValue(
  data,
  fieldOrder = Object.keys(data[0])
) {
  const table = data.map((item) => {
    const tableList = fieldOrder.map((itemList) => item[itemList]);
    return tableList;
  });
  return table;
}

/**
 * @date: 2021/6/7
 * @author 风信子
 * @Description: 方法说明 判断数据类型
 * @method 方法名 getType
 * @param {参数类型} 参数名 obj  参数说明 需要判断的数据
 * @return {返回值类型} 返回值说明  string  number object  array null  等 都是小写字母
 */
export function getType(obj) {
  let type = typeof obj;
  if (type !== "object") {
    return type.toLowerCase();
  }
  return Object.prototype.toString
    .call(obj)
    .replace(/^\[object (\S+)\]$/, "$1")
    .toLowerCase();
}

export function getCookie(key) {
  let arr,
    reg = new RegExp("(^| )" + key + "=([^;]*)(;|$)");
  if (window.document.cookie.match(reg)) {
    arr = window.document.cookie.match(reg);
    return arr[2];
  } else if (process.env.VUE_APP_ENV === "development") {
    return getQueryStringData(key);
  }
  return "";
}
